/**
 * <p>版权所有：中企动力
 * <p>未经本公司许可，不得以任何方式复制或使用本程序任何部分
 */
package com.ce.pms.common.util;

import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.ce.pms.common.model.SysInfo;
import com.ce.pms.exception.BusinessException;
import com.ce.util.BlankUtil;
import com.ce.util.DateUtil;

/**
 * 功能描述: 一个字符串分析类，详见各方法说明
 *
 * @author  付湘辉
 * Created on：  2008-7-7
 * @author
 * update on：
 */

public class StringAnalysiUtil {
	/**
	 * 转义双引号 \"
	 */
	public static final String TROPE_DOUBLE_QUOTES = "\\\\\"";

	/**
	 * 转义百分号 \%
	 */
	public static final String TROPE_PERCENT_SIGN = "\\\\%";

	/**
	 * 转义单引号 ''
	 */
	public static final String TROPE_QUOTES  = "\\'\\'";

	/**
	 * 转义短横线 \-
	 */
	public static final String TROPE_SIDELINE = "\\\\-";

	public static final String TROPE_TEMPLATE_ALL="'_%";
	
	/**
	 * 转义下划横线 \_
	 */
	public static final String TROPE_UNDERLINE = "\\\\_";

	/**
	 * 转义右尖括号 \>
	 */
//	public static final String TROPE_RIGHT_TIP_BRACKETS = "\\\\>";

	/**
	 * 转义左尖括号 \<
	 */
//	public static final String TROPE_LEFT_TIP_BRACKETS = "\\\\<";

	/**
	 * 原始-转义字符键值对
	 */
	private static Map<Character,String> originalTropeMap = java.util.Collections.synchronizedMap(new HashMap<Character, String>());

	static{
		originalTropeMap.put('\'', TROPE_QUOTES);
//		originalTropeMap.put('\"', TROPE_DOUBLE_QUOTES);
		originalTropeMap.put('_', TROPE_UNDERLINE);
		originalTropeMap.put('%', TROPE_PERCENT_SIGN);
//		originalTropeMap.put('-', TROPE_SIDELINE);
	}

//	public static void main(String[] args) {
//		String sss = portfolioFormattedString(new String[]{"lsjdf","345","98345"});
//
//		System.out.println(sss);
//
//		sss = portfolioFormattedString(new String[]{"lsjdf","345","98345"},'|');
//
//		System.out.println(sss);
//
//		List<Long> longList = new ArrayList<Long>();
//		longList.add(12l);
//		longList.add(13l);
//		longList.add(14l);
//		longList.add(15l);
//		sss = portfolioFormattedString(longList);
//		
//		System.out.println(sss);
//		
//		sss = portfolioFormattedString(new Long[]{123l,345l,7345l});
//
//		System.out.println(sss);
//
//		sss = portfolioFormattedString(new Object[]{123.98d,345.64d,7345.32d,"sjflsd",2346l});
//
//		System.out.println(sss);
//
//		sss = portfolioFormattedString(new String[]{"123.98d","345.64d","7345.32d","sjflsd","2346l"},null,null);
//
//		System.out.println(sss);
//
//		sss = portfolioFormattedString(new String[]{},null,null);
//
//		System.out.println(sss);
//
//		sss = "asdfblv_lajsdf%%asdf'lsdjf";
//
//		sss = toTropicalString(sss);
//
//		System.out.println(sss);
//
//		sss = "asdfblv_lajsdf%%asdf'lsdjf";
//
//		sss = toTropicalString(sss,"_'");
//
//		System.out.println(sss);

//		System.out.println('['+""+'\u0000'+""+']');
//
//		String message = "{0}已登记为房间{1}所属业主的家庭成员，<br>不能再次登记或同时登记为其它类型客户。";
//		String res = parseParamString(message, Arrays.asList("lajsdf","1-2A"));
//		
//		 System.out.println(res);
//		String prefix ="JFT",precinctCode="1";
//		Date chargeDate=new Date();
//		Double curDayTimes=3331.6;
//		if (BlankUtil.isBlank(precinctCode)) {
//			throw new BusinessException("charge:charge_precinctcode_isnull_exception",
//							BusinessException.WARNING);
//		}
//		
//		final String speator = "-";
//		NumberFormat nf = NumberFormat.getInstance();
//		nf.setMinimumIntegerDigits(5);
//		nf.setMaximumFractionDigits(0);
//		nf.setGroupingUsed(false);
//		nf.setParseIntegerOnly(true);
//		
//		StringBuffer sb = new StringBuffer();
//		sb.append(prefix).append(speator);
//		sb.append(precinctCode).append(speator);
//		if (BlankUtil.isBlank(chargeDate)) {
//			chargeDate = new Date();
//		}
//		String dateStr = DateUtil.convertDateToStr(chargeDate, DateUtil.DATE_COMPACT_FORMAT);
//		sb.append(dateStr).append(speator);
//		String times = nf.format(++curDayTimes);
//		sb.append(times);
//		System.out.println(sb);
//	}

	/**
	 * 功能描述:  解析一个带参数的异常消息字符串，用列表中的值顺序代替各个参数占位符。
	 *
	 * @author 付湘辉
	 * Created on:2008-7-8
	 *
	 * @param str 带参数的异常消息字符串
	 * @param list 值替换列表
	 * @return String
	 */
	public static String parseExceptionMessageString(String str,List<String> list){
		String tempStr = str;
		if (BlankUtil.isBlank(tempStr)) {
			return "";
		}
		Pattern p = Pattern.compile("\\{\\d{1,}\\}");
		Matcher m1 =  p.matcher(tempStr);
		StringBuffer sb = new StringBuffer();
		for(int i=0;m1.find()&&i<list.size();i++){
			String temp = list.get(i);
			m1.appendReplacement(sb, temp);
		}
		m1.appendTail(sb);

		return sb.toString();
	}

	/**
	 * 功能描述: 用指定分隔符拼接一些对象成为一个字符串
	 *
	 * @author 付湘辉
	 * Created on:2008-7-8
	 *
	 * @param strArray　字符串数组
	 * @param separator　分隔符参数
	 * @return String
	 */
	public static String portfolioFormattedString(Character separator,Object ...objects){
		String[] tempStr = generationStringArray(objects);
		String result = portfolioFormattedString(tempStr, separator, null);
		return result;
	}
	
	/**
	 * 功能描述: 用逗号作分隔符拼接数个字符串元素成为一个字符串。
	 * 如果border不为空，它将作为每个字符串元素的前缀和后缀。
	 * 所拼接的结果将如 border+字符串元素1+border,border+字符串元素2+border,…,border+字符串元素n+border 形式
	 * @author 付湘辉
	 * Created on:2008-7-8
	 *
	 * @param border 
	 * @param strArray 
	 * @return String
	 */
	public static String portfolioFormattedString(Character border,String ... strArray){
		return portfolioFormattedString(strArray, null,border);
	}

	/**
	 * 功能描述: 用逗号作分隔符拼接一个Long列表成为一个字符串
	 *
	 * @author 付湘辉
	 * Created on:2008-7-8
	 *
	 * @param list
	 * @return String
	 */
	public static String portfolioFormattedString(List<Long> list){
		String[] tempStr = generationStringArray(list.toArray(new Long[]{}));

		return portfolioFormattedString(tempStr);
	}
	
	/**
	 * 功能描述: 用逗号作分隔符拼接一些Long对象成为一个字符串
	 *
	 * @author 付湘辉
	 * Created on:2008-7-8
	 *
	 * @param longArray
	 * @return String
	 */
	public static String portfolioFormattedString(Long ... longs){
		String[] tempStr = generationStringArray(longs);

		return portfolioFormattedString(tempStr);
	}

	/**
	 * 功能描述: 用逗号作分隔符拼接一些对象成为一个字符串
	 *
	 * @author 付湘辉
	 * Created on:2008-7-8
	 *
	 * @param objs
	 * @return String
	 */
	public static String portfolioFormattedString(Object ... objs){
		String[] tempStr = generationStringArray(objs);

		return portfolioFormattedString(tempStr);

	}

	/**
	 * 功能描述: 用逗号作分隔符拼接一些字符串成为一个字符串
	 *
	 * @author 付湘辉
	 * Created on:2008-7-8
	 *
	 * @param strArray
	 * @return String
	 */
	public static String portfolioFormattedString(String ... strArray){
		return portfolioFormattedString(strArray, SysInfo.SEPARATOR_COMMA.toCharArray()[0],null);
	}

	/**
	 *
	 * 功能描述: 将所有 str 中的字符替换为其原始字符，原始字符集由本类维护，以便在数据库中操作
	 *
	 * @author 付湘辉
	 * Created on:2008-7-1
	 *
	 * 修改原因：
	 *
	 * @param str
	 * @return String 返回结果
	 */
	public static String toTropicalString(String str){
		String tempStr = str;
		if (BlankUtil.isBlank(tempStr)) {
			return "";
		}

		//替换 originalTropeMap 中所有的字符
		for (Entry<Character, String> entry : originalTropeMap.entrySet()) {
			tempStr = tempStr.replaceAll(entry.getKey().toString(), entry.getValue());
		}

		return tempStr;
	}

	/**
	 *
	 * 功能描述: 将所有出现在参数 templates 中的 str 的字符替换为其原始字符，以便在数据库中操作<br>
	 * 例：传入str 是　"abcc_efgh%ijk"，templates 是　"%'"，那么str中的所有%都会被替换成\%，<br>
	 * 而 "'"并没有在　str 中出现，因此不会出现变化
	 *
	 * @author 付湘辉
	 * Created on:2008-7-1
	 *
	 * 修改原因：
	 *
	 * @param str
	 * @param templates
	 * @return String 返回结果
	 */
	public static String toTropicalString(String str, String templates){
		if (BlankUtil.isBlank(str)) {
			return "";
		}

		String tempStr = str.trim();//前后空格
		if (BlankUtil.isBlank(tempStr)) {
			return "";
		}

		for (Character c : templates.toCharArray()) {
			tempStr = tempStr.replaceAll(c.toString(), originalTropeMap.get(c)==null?c.toString():originalTropeMap.get(c));
		}

		return tempStr;
	}

	/**
	 * 功能描述: 
	 *
	 * @author 付湘辉
	 * Created on:2008-7-10
	 *
	 * 修改原因：
	 * @param longArray
	 * @return String[] 返回结果
	 */
	private static String[] generationStringArray(Object[] objArray) {
		String[] tempStr = new String[objArray.length];
		int i = 0;
		for (Object objValue : objArray) {
			tempStr[i++] = objValue.toString();
		}
		return tempStr;
	}

	/**
	 * 功能描述: 用指定分隔符拼接一个字符串数组成为一个字符串
	 *
	 * @author 付湘辉
	 * Created on:2008-7-8
	 *
	 * @param strArray　  字符串数组
	 * @param separator  分隔符
	 * @param border　    字符边界
	 * @return String
	 */
	private static String portfolioFormattedString(String[] strArray,Character separator,Character border){
		if (strArray==null) {
			return "";
		}
		StringBuffer resultSb = new StringBuffer();
		String tempBorderChar=BlankUtil.isBlank(border)?"":border.toString();
		//默认分隔符为逗号
		String tempSeparator=BlankUtil.isBlank(separator)?SysInfo.SEPARATOR_COMMA:separator.toString();

		int length = strArray.length;
		if (length==0)	return "";
		int i = 0;
		while (i < length) {
			if (strArray[i]==null || strArray[i].length()==0) {
				i++;
				continue;
			}
			resultSb.append(tempBorderChar).append(strArray[i++]).append(tempBorderChar);
            resultSb.append(tempSeparator);//添加一个分隔符
		}

		if (0 < resultSb.length()) {
			resultSb.deleteCharAt(resultSb.length()-1);
		}

		return resultSb.toString();
	}
}
